package abs.dao;

import abs.domain.Companias;

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.skyway.spring.util.dao.AbstractJpaDao;

import org.springframework.dao.DataAccessException;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

/**
 * DAO to manage Companias entities.
 * 
 */
@Repository("CompaniasDAO")
@Transactional
public class CompaniasDAOImpl extends AbstractJpaDao<Companias> implements
		CompaniasDAO {

	/**
	 * Set of entity classes managed by this DAO.  Typically a DAO manages a single entity.
	 *
	 */
	private final static Set<Class<?>> dataTypes = new HashSet<Class<?>>(Arrays.asList(new Class<?>[] { Companias.class }));

	/**
	 * EntityManager injected by Spring for persistence unit absV2
	 *
	 */
	@PersistenceContext(unitName = "absV2")
	private EntityManager entityManager;

	/**
	 * Instantiates a new CompaniasDAOImpl
	 *
	 */
	public CompaniasDAOImpl() {
		super();
	}

	/**
	 * Get the entity manager that manages persistence unit 
	 *
	 */
	public EntityManager getEntityManager() {
		return entityManager;
	}

	/**
	 * Returns the set of entity classes managed by this DAO.
	 *
	 */
	public Set<Class<?>> getTypes() {
		return dataTypes;
	}

	/**
	 * JPQL Query - findCompaniasByCo000clcaContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000clcaContaining(String co000clca) throws DataAccessException {

		return findCompaniasByCo000clcaContaining(co000clca, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000clcaContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000clcaContaining(String co000clca, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000clcaContaining", startResult, maxRows, co000clca);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000inccContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000inccContaining(String co000incc) throws DataAccessException {

		return findCompaniasByCo000inccContaining(co000incc, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000inccContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000inccContaining(String co000incc, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000inccContaining", startResult, maxRows, co000incc);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000mepr
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000mepr(Integer co000mepr) throws DataAccessException {

		return findCompaniasByCo000mepr(co000mepr, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000mepr
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000mepr(Integer co000mepr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000mepr", startResult, maxRows, co000mepr);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000repr
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000repr(String co000repr) throws DataAccessException {

		return findCompaniasByCo000repr(co000repr, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000repr
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000repr(String co000repr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000repr", startResult, maxRows, co000repr);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000mofuContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000mofuContaining(String co000mofu) throws DataAccessException {

		return findCompaniasByCo000mofuContaining(co000mofu, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000mofuContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000mofuContaining(String co000mofu, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000mofuContaining", startResult, maxRows, co000mofu);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000nocia
	 *
	 */
	@Transactional
	public Companias findCompaniasByCo000nocia(String co000nocia) throws DataAccessException {

		return findCompaniasByCo000nocia(co000nocia, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000nocia
	 *
	 */

	@Transactional
	public Companias findCompaniasByCo000nocia(String co000nocia, int startResult, int maxRows) throws DataAccessException {
		try {
			Query query = createNamedQuery("findCompaniasByCo000nocia", startResult, maxRows, co000nocia);
			return (abs.domain.Companias) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	/**
	 * JPQL Query - findCompaniasByCo000nomb
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000nomb(String co000nomb) throws DataAccessException {

		return findCompaniasByCo000nomb(co000nomb, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000nomb
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000nomb(String co000nomb, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000nomb", startResult, maxRows, co000nomb);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000estaContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000estaContaining(String co000esta) throws DataAccessException {

		return findCompaniasByCo000estaContaining(co000esta, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000estaContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000estaContaining(String co000esta, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000estaContaining", startResult, maxRows, co000esta);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000idtr
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000idtr(String co000idtr) throws DataAccessException {

		return findCompaniasByCo000idtr(co000idtr, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000idtr
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000idtr(String co000idtr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000idtr", startResult, maxRows, co000idtr);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000mofu
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000mofu(String co000mofu) throws DataAccessException {

		return findCompaniasByCo000mofu(co000mofu, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000mofu
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000mofu(String co000mofu, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000mofu", startResult, maxRows, co000mofu);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000fir2
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000fir2(String co000fir2) throws DataAccessException {

		return findCompaniasByCo000fir2(co000fir2, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000fir2
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000fir2(String co000fir2, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000fir2", startResult, maxRows, co000fir2);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000load
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000load(String co000load) throws DataAccessException {

		return findCompaniasByCo000load(co000load, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000load
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000load(String co000load, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000load", startResult, maxRows, co000load);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000feadBefore
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000feadBefore(java.util.Calendar co000fead) throws DataAccessException {

		return findCompaniasByCo000feadBefore(co000fead, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000feadBefore
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000feadBefore(java.util.Calendar co000fead, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000feadBefore", startResult, maxRows, co000fead);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000nregContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000nregContaining(String co000nreg) throws DataAccessException {

		return findCompaniasByCo000nregContaining(co000nreg, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000nregContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000nregContaining(String co000nreg, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000nregContaining", startResult, maxRows, co000nreg);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000baca
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000baca(java.math.BigDecimal co000baca) throws DataAccessException {

		return findCompaniasByCo000baca(co000baca, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000baca
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000baca(java.math.BigDecimal co000baca, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000baca", startResult, maxRows, co000baca);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000cont
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000cont(String co000cont) throws DataAccessException {

		return findCompaniasByCo000cont(co000cont, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000cont
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000cont(String co000cont, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000cont", startResult, maxRows, co000cont);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000direContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000direContaining(String co000dire) throws DataAccessException {

		return findCompaniasByCo000direContaining(co000dire, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000direContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000direContaining(String co000dire, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000direContaining", startResult, maxRows, co000dire);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000nociaContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000nociaContaining(String co000nocia) throws DataAccessException {

		return findCompaniasByCo000nociaContaining(co000nocia, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000nociaContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000nociaContaining(String co000nocia, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000nociaContaining", startResult, maxRows, co000nocia);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000femoBefore
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000femoBefore(java.util.Calendar co000femo) throws DataAccessException {

		return findCompaniasByCo000femoBefore(co000femo, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000femoBefore
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000femoBefore(java.util.Calendar co000femo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000femoBefore", startResult, maxRows, co000femo);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByPrimaryKey
	 *
	 */
	@Transactional
	public Companias findCompaniasByPrimaryKey(String co000nocia) throws DataAccessException {

		return findCompaniasByPrimaryKey(co000nocia, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByPrimaryKey
	 *
	 */

	@Transactional
	public Companias findCompaniasByPrimaryKey(String co000nocia, int startResult, int maxRows) throws DataAccessException {
		try {
			Query query = createNamedQuery("findCompaniasByPrimaryKey", startResult, maxRows, co000nocia);
			return (abs.domain.Companias) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	/**
	 * JPQL Query - findCompaniasByCo000femo
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000femo(java.util.Calendar co000femo) throws DataAccessException {

		return findCompaniasByCo000femo(co000femo, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000femo
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000femo(java.util.Calendar co000femo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000femo", startResult, maxRows, co000femo);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000notr
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000notr(String co000notr) throws DataAccessException {

		return findCompaniasByCo000notr(co000notr, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000notr
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000notr(String co000notr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000notr", startResult, maxRows, co000notr);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000fir1
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000fir1(String co000fir1) throws DataAccessException {

		return findCompaniasByCo000fir1(co000fir1, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000fir1
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000fir1(String co000fir1, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000fir1", startResult, maxRows, co000fir1);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000lomoContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000lomoContaining(String co000lomo) throws DataAccessException {

		return findCompaniasByCo000lomoContaining(co000lomo, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000lomoContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000lomoContaining(String co000lomo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000lomoContaining", startResult, maxRows, co000lomo);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000fir1Containing
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000fir1Containing(String co000fir1) throws DataAccessException {

		return findCompaniasByCo000fir1Containing(co000fir1, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000fir1Containing
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000fir1Containing(String co000fir1, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000fir1Containing", startResult, maxRows, co000fir1);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000notrContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000notrContaining(String co000notr) throws DataAccessException {

		return findCompaniasByCo000notrContaining(co000notr, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000notrContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000notrContaining(String co000notr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000notrContaining", startResult, maxRows, co000notr);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000inut
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000inut(String co000inut) throws DataAccessException {

		return findCompaniasByCo000inut(co000inut, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000inut
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000inut(String co000inut, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000inut", startResult, maxRows, co000inut);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000nreg
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000nreg(String co000nreg) throws DataAccessException {

		return findCompaniasByCo000nreg(co000nreg, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000nreg
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000nreg(String co000nreg, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000nreg", startResult, maxRows, co000nreg);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000incf
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000incf(String co000incf) throws DataAccessException {

		return findCompaniasByCo000incf(co000incf, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000incf
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000incf(String co000incf, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000incf", startResult, maxRows, co000incf);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000loadContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000loadContaining(String co000load) throws DataAccessException {

		return findCompaniasByCo000loadContaining(co000load, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000loadContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000loadContaining(String co000load, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000loadContaining", startResult, maxRows, co000load);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000fead
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000fead(java.util.Calendar co000fead) throws DataAccessException {

		return findCompaniasByCo000fead(co000fead, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000fead
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000fead(java.util.Calendar co000fead, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000fead", startResult, maxRows, co000fead);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000incpContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000incpContaining(String co000incp) throws DataAccessException {

		return findCompaniasByCo000incpContaining(co000incp, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000incpContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000incpContaining(String co000incp, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000incpContaining", startResult, maxRows, co000incp);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000femoAfter
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000femoAfter(java.util.Calendar co000femo) throws DataAccessException {

		return findCompaniasByCo000femoAfter(co000femo, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000femoAfter
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000femoAfter(java.util.Calendar co000femo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000femoAfter", startResult, maxRows, co000femo);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000idtrContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000idtrContaining(String co000idtr) throws DataAccessException {

		return findCompaniasByCo000idtrContaining(co000idtr, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000idtrContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000idtrContaining(String co000idtr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000idtrContaining", startResult, maxRows, co000idtr);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000incfContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000incfContaining(String co000incf) throws DataAccessException {

		return findCompaniasByCo000incfContaining(co000incf, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000incfContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000incfContaining(String co000incf, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000incfContaining", startResult, maxRows, co000incf);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000dire
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000dire(String co000dire) throws DataAccessException {

		return findCompaniasByCo000dire(co000dire, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000dire
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000dire(String co000dire, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000dire", startResult, maxRows, co000dire);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000contContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000contContaining(String co000cont) throws DataAccessException {

		return findCompaniasByCo000contContaining(co000cont, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000contContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000contContaining(String co000cont, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000contContaining", startResult, maxRows, co000cont);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000esta
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000esta(String co000esta) throws DataAccessException {

		return findCompaniasByCo000esta(co000esta, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000esta
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000esta(String co000esta, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000esta", startResult, maxRows, co000esta);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000lomo
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000lomo(String co000lomo) throws DataAccessException {

		return findCompaniasByCo000lomo(co000lomo, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000lomo
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000lomo(String co000lomo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000lomo", startResult, maxRows, co000lomo);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000fir2Containing
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000fir2Containing(String co000fir2) throws DataAccessException {

		return findCompaniasByCo000fir2Containing(co000fir2, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000fir2Containing
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000fir2Containing(String co000fir2, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000fir2Containing", startResult, maxRows, co000fir2);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000meci
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000meci(Integer co000meci) throws DataAccessException {

		return findCompaniasByCo000meci(co000meci, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000meci
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000meci(Integer co000meci, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000meci", startResult, maxRows, co000meci);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000feadAfter
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000feadAfter(java.util.Calendar co000fead) throws DataAccessException {

		return findCompaniasByCo000feadAfter(co000fead, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000feadAfter
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000feadAfter(java.util.Calendar co000fead, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000feadAfter", startResult, maxRows, co000fead);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000incc
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000incc(String co000incc) throws DataAccessException {

		return findCompaniasByCo000incc(co000incc, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000incc
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000incc(String co000incc, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000incc", startResult, maxRows, co000incc);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000incp
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000incp(String co000incp) throws DataAccessException {

		return findCompaniasByCo000incp(co000incp, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000incp
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000incp(String co000incp, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000incp", startResult, maxRows, co000incp);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000clca
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000clca(String co000clca) throws DataAccessException {

		return findCompaniasByCo000clca(co000clca, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000clca
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000clca(String co000clca, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000clca", startResult, maxRows, co000clca);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000nosu
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000nosu(Integer co000nosu) throws DataAccessException {

		return findCompaniasByCo000nosu(co000nosu, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000nosu
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000nosu(Integer co000nosu, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000nosu", startResult, maxRows, co000nosu);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000inutContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000inutContaining(String co000inut) throws DataAccessException {

		return findCompaniasByCo000inutContaining(co000inut, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000inutContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000inutContaining(String co000inut, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000inutContaining", startResult, maxRows, co000inut);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findAllCompaniass
	 *
	 */
	@Transactional
	public Set<Companias> findAllCompaniass() throws DataAccessException {

		return findAllCompaniass(-1, -1);
	}

	/**
	 * JPQL Query - findAllCompaniass
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findAllCompaniass(int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findAllCompaniass", startResult, maxRows);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000reprContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000reprContaining(String co000repr) throws DataAccessException {

		return findCompaniasByCo000reprContaining(co000repr, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000reprContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000reprContaining(String co000repr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000reprContaining", startResult, maxRows, co000repr);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * JPQL Query - findCompaniasByCo000nombContaining
	 *
	 */
	@Transactional
	public Set<Companias> findCompaniasByCo000nombContaining(String co000nomb) throws DataAccessException {

		return findCompaniasByCo000nombContaining(co000nomb, -1, -1);
	}

	/**
	 * JPQL Query - findCompaniasByCo000nombContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Companias> findCompaniasByCo000nombContaining(String co000nomb, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCompaniasByCo000nombContaining", startResult, maxRows, co000nomb);
		return new LinkedHashSet<Companias>(query.getResultList());
	}

	/**
	 * Used to determine whether or not to merge the entity or persist the entity when calling Store
	 * @see store
	 * 
	 *
	 */
	public boolean canBeMerged(Companias entity) {
		return true;
	}
}
